/**
 * 修改记录:
 * 25-09-11     郑朝军
 */

/**
 * uni.cxapp.ApiCalls
 * ZGIS-API调用相关方法
 *
 * @class
 * @memberof    uni.cxapp.ApiCalls
 */
export default
{
  methods:
  {
    // ==============================
    // 数据操作 API
    // ==============================

    /**
     * 调用新增API
     * @param {number} major 主类型
     * @param {number} minor 子类型
     * @param {Object} data 数据
     * @param {number} retAtt 是否返回完整记录 0-不返回 1-返回
     * @returns {Promise<Object>} 响应结果
     */
    async callAddApi(major, minor, data, retAtt = 0)
    {
      // 使用DataSvr.add API         
      try
      {
        // 实际调用DataSvr.add
        return await uni.cxapp.DataSvr.add(major, minor, data, retAtt)
      }
      catch (error)
      {
        console.error('新增API调用失败:', error)
        throw error
      }
    },

    /**
     * 调用更新API
     * @param {number} major 主类型
     * @param {number} minor 子类型
     * @param {Object} data 数据
     * @param {string} cols 指定更新的字段，用逗号分隔
     * @param {number} retAtt 是否返回完整记录 0-不返回 1-返回
     * @returns {Promise<Object>} 响应结果
     */
    async callUpdateApi(major, minor, data, cols = null, retAtt = 0)
    {    
      try
      {
        // 如果需要返回完整记录，在data中添加retAtt参数
        if (retAtt === 1)
        {
          data.retAtt = 1
        }

        // 实际调用DataSvr.update
        return await uni.cxapp.DataSvr.update(major, minor, data, cols, retAtt)
      }
      catch (error)
      {
        console.error('更新API调用失败:', error)
        throw error
      }
    },

    /**
     * 调用ID查询API
     * @param {number} major 主类型
     * @param {number} minor 子类型
     * @param {number} id 记录ID
     * @param {string} cols 指定返回的字段，用逗号分隔
     * @returns {Promise<Object>} 响应结果
     */
    async callQueryByIdApi(major, minor, id, cols = null)
    {       
      try
      {
        const params =
        {
          args: [['id', '=', id, null]]
        }

        if (cols)
        {
          params.cols = cols
        }

        // 实际调用DataSvr.query
        const result = await uni.cxapp.DataSvr.query(major, minor, params)
        return result && result.length > 0 ? result[0] : null
      }
      catch (error)
      {
        console.error('ID查询API调用失败:', error)
        throw error
      }
    },

		/**
     * 通过ID查询数据
     * @param {number} id 记录ID
     * @returns {Promise<void>}
     */
    async queryById(id)
    {
      try
      {
        this.isLoading = true
        this.loadingMessage = '正在获取属性...'

        const result = await this.callQueryByIdApi(this.major, this.minor, id)
        this.internalAttMap = { ...result }

        if (this.onReady)
        {
          this.onReady(this.internalAttMap)
        }
      }
      catch (error)
      {
        console.error('查询数据失败:', error)
        this.handleError(error)
      }
      finally
      {
        this.isLoading = false
      }
    },

    // ==============================
    // 配置信息获取
    // ==============================

    /**
     * 获取TabCfg配置
     * @param {string} name 配置名称
     * @param {string} [matchBy='name'] 匹配方式，'name'或'tab'
     * @returns {Promise<Object|null>} 配置对象
     */
    async getTabCfg(name, matchBy = 'name')
    {       
      return uni.cxapp.InitSvrMethod.getTabcfg().find(e => e[matchBy] === name)
    },
      
    /**
     * 根据名称获取实体
     * @param {string} tabName 表名
     * @returns {Promise<Object|null>} 实体对象
     */
    async getEntityByName(tabName)
    {    
      try
      {
        return await uni.cxapp.entity.queryEntityByName(tabName)
      }
      catch (error)
      {
        console.error('根据名称获取实体失败:', error)
        throw error
      }
    },

    /**
     * 获取实体信息
     * @param {number} major 主类型
     * @param {number} minor 子类型
     * @returns {Promise<Object|null>} 实体对象
     */
    async getEntity(major, minor) 
    {
      // 使用EntityManager.queryEntity API        
      try 
      {
        return await uni.cxapp.entity.queryEntity(major, minor)
      } 
      catch (error) 
      {
        console.error('获取实体信息失败:', error)
        return null
      }
    },

    /**
     * 获取表名 
     * @returns {Promise<string|null>} 表名
     */
    getTabName() 
    {            
      return this.internalEntity.name
    },
      
    /**
     * 查询字段列表
     * @param {string} tabName 表名
     * @param {boolean} order 是否按照disporder排序，默认true
     * @param {boolean} removeOrder0 是否移除disporder为0的记录，默认false
     * @returns {Promise<Array>} 字段列表
     */
    async queryFldList(tabName, order = true, removeOrder0 = false)
    {                   
      try
      {           
        const flds = await uni.cxapp.fld.queryFldListAuto(
          {
            tabname: tabName,
            order: order,
            removeOrder0: removeOrder0
          })
         
        return flds
      }
      catch (error)
      {
        console.error('查询字段列表失败:', error)
        throw error
      }
    },

    // ==============================
    // 消息提示
    // ==============================

    /**
     * 显示错误消息（IAttController接口方法）
     * @param {string} message 错误消息
     */
    showErrorMsg(message) 
    {
      uni.cxapp.Toast(message)
      // 触发错误事件
      this.$emit('error-msg', message)
    },

    /**
     * 显示成功消息
     * @param {string} message 成功消息
     */
    showSuccessMsg(message) 
    {   
      // 触发成功消息事件
      this.$emit('success-msg', message)
    },

    // ==============================
    // 错误处理
    // ==============================

    /**
     * 错误处理
     * @param {Error} error 错误对象
     */
    handleError(error) 
    {
      if (this.onError) 
      {
        this.onError(error, error.stack)
      }

      this.$emit('error', error)
    },

    // ==============================
    // 模式判断
    // ==============================

    /**
     * 判断是否为查看模式
     * @returns {boolean} 是否为查看模式
     */
    isViewMode() 
    {
      return this.internalMode === uni.cxapp.CxConst.ATT_VIEW
    },

    /**
     * 判断是否为编辑模式
     * @returns {boolean} 是否为编辑模式
     */
    isEditMode() 
    {
      return this.internalMode === uni.cxapp.CxConst.ATT_EDIT
    },

    /**
     * 判断是否为新增模式
     * @returns {boolean} 是否为新增模式
     */
    isAddMode() 
    {
      return this.internalMode === uni.cxapp.CxConst.ATT_ADD
    },

    /**
     * 判断是否为可编辑模式（编辑或新增）
     * @returns {boolean} 是否为可编辑模式
     */
    isEditableMode() 
    {
      return this.internalMode === uni.cxapp.CxConst.ATT_EDIT || this.internalMode === uni.cxapp.CxConst.ATT_ADD
    },

    /**
     * 验证并规范化模式值
     * @param {Number} mode 模式值
     * @returns {Number} 有效的模式值
     */
    validateMode(mode) 
    {
      // 定义有效的模式值
      const validModes = [
        uni.cxapp.CxConst.ATT_VIEW,  // 6 - 查询/查看模式
        uni.cxapp.CxConst.ATT_EDIT,  // 5 - 修改/编辑模式  
        uni.cxapp.CxConst.ATT_ADD    // 7 - 添加/新增模式
      ]

      // 检查传入的mode是否有效
      if (typeof mode === 'number' && validModes.includes(mode)) 
      {
        return mode
      }

      // 如果mode无效，根据attMap是否有id来判断默认模式
      if (this.attMap && this.attMap.id) 
      {
        // 有id默认为编辑模式
        return uni.cxapp.CxConst.ATT_EDIT
      }

      // 没有id默认为添加模式
      return uni.cxapp.CxConst.ATT_ADD
    },

    /**
     * 获取模式名称
     * @returns {string} 模式名称
     */
    getModeName() 
    {
      switch (this.internalMode) 
      {
        case uni.cxapp.CxConst.ATT_VIEW:
          return '查看模式'
        case uni.cxapp.CxConst.ATT_EDIT:
          return '编辑模式'
        case uni.cxapp.CxConst.ATT_ADD:
          return '新增模式'
        default:
          return '未知模式'
      }
    },

    // ==============================
    // 字段值同步
    // ==============================

    /**
     * 同步字段值 - 当internalAttMap变化时，同步更新字段fld的value属性
     * @param {Object} attMap 属性映射对象
     */
    syncFieldValues(attMap) 
    {
      if (!attMap || !Array.isArray(this.internalFldList)) 
      {
        return
      }

      // 遍历字段列表，同步更新字段值
      this.internalFldList.forEach(fld => 
      {
        if (fld && fld.colname && attMap.hasOwnProperty(fld.colname)) 
        {        
          // 更新字段的value属性              
          this.$set(fld, 'value', attMap[fld.colname])
        }
      })

      // 触发字段值同步事件
      this.$emit('fld-values-synced', attMap)
    },       
  }
}